{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## numpy其实就是一个多维的数组对象\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2\n",
      " 3 4 5 1 2 3 4 5 1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "data = [1, 2, 3, 4,5]\n",
    "n = np.array(data*10)\n",
    "print(n)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "dtype('int32')"
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n.shape     # shape属性表示获取到np数组的维度\n",
    "n.dtype     # dtype属性表示获取到数组的类型\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 嵌套序列：是由一组等长列表组成的列表\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "int32\n",
      "(2, 5)\n"
     ]
    }
   ],
   "source": [
    "arr = [[1, 2,3, 4,5],[1, 2,3, 4,5]]\n",
    "arr2 = np.array(arr)\n",
    "print(arr2.ndim)    # ndim代表了维度\n",
    "print(arr2.dtype)\n",
    "print(arr2.shape)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## np对数据类型的一个判断"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['1' '2' '3' '4']\n",
      " ['6' '7' '8' '9']]\n",
      "<U1\n"
     ]
    }
   ],
   "source": [
    "arr = [['1', '2',3, 4], [6, 7, 8, 9]]\n",
    "arr2 = np.array(arr)\n",
    "print(arr2)\n",
    "print(arr2.dtype)   # unicode类型, numpy的字符串"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# numpy 进行指定长度数组的创建"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "np.zeros(10), np.ones((2,3))\n",
    "print(np.arange(10))  # arange是range函数的数组版本\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.2  1.6  1.8 -2.4 -5.9]\n",
      "float64\n",
      "[ 1  1  1 -2 -5]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1.2, 1.6, 1.8, -2.4, -5.9])\n",
    "print(arr)\n",
    "print(arr.dtype)\n",
    "print(arr.astype(np.int64))     # 强制转换astype()\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 矢量化\n",
    "数组通常不用在编写循环的情况下就可以进行批量运算"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6  8 10 12]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1, 2, 3, 4])\n",
    "arr2 = np.array([5, 6, 7, 8])\n",
    "print(arr1+arr2)\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## numpy数组的索引和切片操作"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "1\n",
      "[4 5 6 7 8 9]\n",
      "[11 11 11  3  4  5  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "print(arr)\n",
    "print(arr[1])\n",
    "print(arr[4:])\n",
    "\n",
    "arr_copy = arr.copy()\n",
    "arr_copy[0:3] = 11\n",
    "print(arr_copy)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# 二维数组的访问方式\n",
    "arr1 = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(arr1[0][1])\n",
    "print(arr1[0,1])\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False False]\n",
      "[False False False]\n",
      "[ True False  True]\n"
     ]
    }
   ],
   "source": [
    "# numpy数组的比较运算\n",
    "names = np.array(['Tony', 'Jack', 'Robin'])\n",
    "print(names == 'Tony')\n",
    "print((names == 'Tony') & (names == 'Robin'))   # and操作\n",
    "print((names == 'Tony') | (names == 'Robin'))   # or操作\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 花式索引 fancy index\n",
    "## 它是一个numpy中的一个属于， 指的是利用整个数组进行索引"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 4. 4. 4.]\n",
      " [2. 2. 2. 2.]\n",
      " [0. 0. 0. 0.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.empty((8, 4))\n",
    "# print(arr)\n",
    "for i in range(8):\n",
    "    arr[i] = i\n",
    "# print(arr)\n",
    "# 以一个特定的顺序来选取行中的子集， 我们传入一个指定顺序的整数列表， 或数组\n",
    "# 这里也可以用负数从末尾获取\n",
    "print(arr[[4, 2, 0, 1]])\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5  6  7]\n",
      " [20 21 22 23]\n",
      " [28 29 30 31]\n",
      " [ 8  9 10 11]]\n",
      "[ 4 23 29 10]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(32).reshape((8,4))\n",
    "print(arr[[1, 5, 7, 2]])\n",
    "print(arr[[1, 5, 7, 2], [0,3, 1, 2]])\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 数组转置和轴兑换\n",
    "转置就是重塑数组的一种特殊的形式，常用的方法T和transpose"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n",
      "[[ 0  5 10]\n",
      " [ 1  6 11]\n",
      " [ 2  7 12]\n",
      " [ 3  8 13]\n",
      " [ 4  9 14]]\n",
      "[[ 0  5 10]\n",
      " [ 1  6 11]\n",
      " [ 2  7 12]\n",
      " [ 3  8 13]\n",
      " [ 4  9 14]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(15).reshape((3,5))\n",
    "print(arr)\n",
    "print(arr.transpose())\n",
    "print(arr.T)\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n",
      "[[[ 0 12]\n",
      "  [ 4 16]\n",
      "  [ 8 20]]\n",
      "\n",
      " [[ 1 13]\n",
      "  [ 5 17]\n",
      "  [ 9 21]]\n",
      "\n",
      " [[ 2 14]\n",
      "  [ 6 18]\n",
      "  [10 22]]\n",
      "\n",
      " [[ 3 15]\n",
      "  [ 7 19]\n",
      "  [11 23]]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(24).reshape((2,3, 4))\n",
    "print(arr)\n",
    "print(arr.transpose())\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 条件逻辑转数组\n",
    "np.where等同于x if condition else y 矢量化的一个版本x if condition else y\n",
    "表示的意思是当条件condition成立时，表达式的返回值是x，不成立时返回值是y\n",
    "np.where的写法，一般用于根据一个数组产生一个新的数组，跟python中函数式变成中的map\n",
    "reduce等函数类似。"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.1, 1.2, 2.3]\n",
      "[2.1 1.2 2.3]\n"
     ]
    }
   ],
   "source": [
    "x_arr = np.array([1.1,1.2,1.3])\n",
    "y_arr = np.array([2.1,2.2,2.3])\n",
    "conditions = np.array([False,True,False])\n",
    "# zip接收的参数就是可迭代的对象\n",
    "# zip()函数用于将可迭代的对象作为参数，将对象中对应的元素变成一个个元祖，然后返回\n",
    "# 由这些元祖组成的列表\n",
    "result = [(x if c else y) for x,y,c in zip(x_arr,y_arr,conditions)]\n",
    "print(result)\n",
    "r = np.where(conditions,x_arr,y_arr)\n",
    "# 第一个参数表示判断条件。\n",
    "print(r)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.19738126  1.72070325  0.97722609  0.82864117]\n",
      " [-0.09538495  0.58733762  0.7085552  -2.03225134]\n",
      " [ 1.87573104  0.77422306 -0.28877912 -3.16003503]\n",
      " [-0.62098953  0.26598576 -0.70768072  0.56822319]]\n",
      "[[-2  2  2  2]\n",
      " [-2  2  2 -2]\n",
      " [ 2  2 -2 -2]\n",
      " [-2  2 -2  2]]\n",
      "[[-1.19738126  2.          2.          2.        ]\n",
      " [-0.09538495  2.          2.         -2.03225134]\n",
      " [ 2.          2.         -0.28877912 -3.16003503]\n",
      " [-0.62098953  2.         -0.70768072  2.        ]]\n"
     ]
    }
   ],
   "source": [
    "# 值替换\n",
    "arr = np.random.randn(4,4)\n",
    "# np.random.rand()表示随机样本位于[0,1]\n",
    "# np.random.randn()表示从标准正态分布中返回一个或多个值\n",
    "print(arr)\n",
    "arr_1 = np.where(arr>0,2,-2)\n",
    "print(arr_1)\n",
    "r = np.where(arr>0,2,arr)\n",
    "print(r)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## numpy的数学运算\n",
    "常用函数 sun mean std"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.47652527  1.41165691  0.8596513  -0.65297551]\n",
      " [-1.12283572 -0.32562432  0.06491766 -0.66273944]\n",
      " [ 0.67690758 -0.12190792 -2.15132198  1.54236556]\n",
      " [-0.36341653  1.53224474  1.3725665   0.4453589 ]]\n",
      "0.18633581117759718\n",
      "0.18633581117759718\n",
      "2.981372978841555\n",
      "1.0210960277491894\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.random.randn(4,4)\n",
    "print(arr)\n",
    "print(arr.mean())\n",
    "print(np.mean(arr))\n",
    "print(arr.sum())\n",
    "print(arr.std())    # 标准差"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 数组排序"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.49632254 0.57748375 0.00349111 0.37394815]\n",
      " [0.82747514 0.34853714 0.58470556 0.22609099]\n",
      " [0.45202219 0.63306414 0.41411006 0.93354945]\n",
      " [0.03055318 0.37954232 0.92336542 0.96527462]]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Cannot specify order when the array has no fields.",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "\u001B[1;32m<ipython-input-14-7010cc529c17>\u001B[0m in \u001B[0;36m<module>\u001B[1;34m\u001B[0m\n\u001B[0;32m      1\u001B[0m \u001B[0marr\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mnp\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mrandom\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mrand\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;36m4\u001B[0m\u001B[1;33m,\u001B[0m \u001B[1;36m4\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m      2\u001B[0m \u001B[0mprint\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0marr\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[1;32m----> 3\u001B[1;33m \u001B[0marr\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0msort\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0maxis\u001B[0m\u001B[1;33m=\u001B[0m\u001B[1;36m0\u001B[0m\u001B[1;33m,\u001B[0m\u001B[0morder\u001B[0m\u001B[1;33m=\u001B[0m\u001B[1;36m0\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0m\u001B[0;32m      4\u001B[0m \u001B[0mprint\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0marr\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m      5\u001B[0m \u001B[1;33m\u001B[0m\u001B[0m\n",
      "\u001B[1;31mValueError\u001B[0m: Cannot specify order when the array has no fields."
     ]
    }
   ],
   "source": [
    "arr = np.random.rand(4, 4)\n",
    "print(arr)\n",
    "arr.sort(axis=0) # 列排序axis=0，行排序：axis=1\n",
    "print(arr)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## numpy的文件操作\n",
    "numpy可以读写磁盘上的文本数据或者是二进制数据，主要应用的函数式：np.save\n",
    "和np.load，默认情况下数据是以未压缩的原始二进制格式保存在扩展名为.npy的文件中"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.10049555 -1.07767287  0.08152697 -1.36371093]\n"
     ]
    },
    {
     "data": {
      "text/plain": "array([-0.10049555, -1.07767287,  0.08152697, -1.36371093])"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(4)\n",
    "print(arr)\n",
    "np.save('any_array', arr)\n",
    "np.load('any_array.npy')\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "data": {
      "text/plain": "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 保存为一个压缩文件\n",
    "arr = np.arange(10)\n",
    "np.savez('any_array_1', a=arr)  # 数组以关键字参数的形式传入\n",
    "np.load('any_array_1.npz')['a']"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [
    {
     "data": {
      "text/plain": "array(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ''], dtype='<U1')"
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "np.savetxt(\"arr_array.txt\", arr, delimiter=',',newline=',',fmt='%d')\n",
    "# file = open('arr_array.txt')\n",
    "np.loadtxt('arr_array.txt', delimiter=',',dtype=str)\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 线性代数\n",
    "dot  矩阵的乘法运算\n",
    "trace 计算对角线元素的和\n",
    "det    计算矩阵的行列式\n",
    "eig   计算方针的本征值和本证向量\n",
    "inv   计算方针的逆"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随机漫步\n",
    "# 求什么时候第一次，距离初始点10步远\n",
    "import matplotlib.pyplot as plt\n",
    "position = 0 # 初始化一个位置的值\n",
    "walk = [position]\n",
    "steps = 1000 # 步数的设置\n",
    "for i in range(steps):\n",
    "    step = 1 if np.random.randint(0,2) else -1\n",
    "    position += step\n",
    "    walk.append(position)\n",
    "plt.plot(walk)\n",
    "# 求什么时候第一次，距离初始点10步远\n",
    "print(np.argmax((np.abs(walk)>10)))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "outputs": [],
   "source": [
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}